package cn.jd.pet.service.impl;


import cn.jd.pet.domain.PetType;

import cn.jd.pet.mapper.PetTypeMapper;
import cn.jd.pet.service.IPetTypeService;
import cn.jd.basic.service.impl.BasicServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author jd
 * @since 2022-10-28
 */
@Service
public class PetTypeServiceImpl extends BasicServiceImpl<PetType> implements IPetTypeService {

    @Autowired
    private PetTypeMapper petTypeMapper;

    @Override
    public List<PetType> findPetTree() {
        List<PetType> allPetTypes = petTypeMapper.findAll();
        List<PetType> result = new ArrayList<>();
        if(CollectionUtils.isEmpty(allPetTypes)){
            return result;
        }
        // 用Stream流将集合转成map
        Map<Long, PetType> collect = new HashMap<>();
        for (PetType allPetType : allPetTypes) {
            if (collect.put(allPetType.getId(), allPetType) != null) {
                throw new IllegalStateException("Duplicate key");
            }
        }

        // 组装数据
        for (PetType petType : allPetTypes) {
            if (null != petType.getPid()){
                PetType parent = collect.get(petType.getPid());
                if(parent==null){
                    break;
                }
                parent.getChildren().add(petType);

            }else {
                result.add(petType);
            }
        }
        return result;
    }

    @Override
    public void remove(Long id) {
        /*super.remove(id);*/
        // 创建一个集合用来装需要删除类型的的id集合
        ArrayList<Long> ids = new ArrayList<>();
        // 创建一个集合用来删除宠物
        // 添加本级删除的id
        ids.add(id);
        // 查询所有的类型数据
        List<PetType> types = petTypeMapper.findAll();
        // 查询所有需要删除的宠物类型
        List<PetType> collect = types.stream().filter(type -> {
            return id.equals(type.getPid());
        }).map((type) -> {
            // 获取子集集合
            type.setChildren(getChildrens(type, types,ids));
            return type;
        }).collect(Collectors.toList());
        // 获取删除的子集id
        collect.forEach(type->{
            ids.add(type.getId());
        });
        petTypeMapper.deleteByAll(ids);

    }
    public List<PetType> getChildrens(PetType type, List<PetType> types,ArrayList<Long> ids) {
        //过滤找到petType的子菜单
        List<PetType> childrens = types.stream().filter(type1 -> {
            return type.getId().equals(type1.getPid());
            //同样，子级也可能有自己的 · 子集，所以需要递归.map的作用便是让元素以另一种形式输出。
        }).map(type1 -> {
            type1.setChildren(getChildrens(type1, types,ids));
            return type1;
        }).collect(Collectors.toList());
        return childrens;
    }
}
